async fn get_payload(
        &self,
        payload_id: PayloadId,
        version: PayloadVersion,
    ) -> RpcResult<OpExecutionPayloadEnvelope> {
           // --snip--
           
            if let Ok(Some(builder_payload)) = builder_payload {
                if self.execution_mode().is_dry_run() {
                    (l2_payload, PayloadSource::L2)
                } else if let Some(selection_policy) = &self.block_selection_policy {
                    selection_policy.select_block(builder_payload, l2_payload)
                }

                //--snip--
     };

/// Defines the strategy for choosing between the builder block and the L2 client block
/// during block production.
#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, clap::ValueEnum)]
pub enum BlockSelectionPolicy {
    /// Selects the block based on gas usage.
    ///
    /// If the builder block uses less than 10% of the gas used by the L2 client block,
    /// the L2 block is selected instead. This prevents propagation of valid but empty
    /// builder blocks and mitigates issues where the builder is not receiving enough
    /// transactions due to networking or peering failures.
    GasUsed,
}

impl BlockSelectionPolicy {
    pub fn select_block(
        &self,
        builder_payload: OpExecutionPayloadEnvelope,
        l2_payload: OpExecutionPayloadEnvelope,
    ) -> (OpExecutionPayloadEnvelope, PayloadSource) {
        match self {
            BlockSelectionPolicy::GasUsed => {
                let builder_gas = builder_payload.gas_used() as f64;
                let l2_gas = l2_payload.gas_used() as f64;

                // Select the L2 block if the builder block uses less than 90% of the gas.
                // This avoids selecting empty or severely underfilled blocks,
                if builder_gas < l2_gas * 0.1 {
                    (l2_payload, PayloadSource::L2)
                } else {
                    (builder_payload, PayloadSource::Builder)
                }
            }
        }
    }
}